在 Java 中，`flatMap` 是 `Stream` API 中的一个重要方法，用于将嵌套的集合或流“扁平化”为单一的流。它通常用于处理嵌套结构（如 `List<List<T>>` 或 `Stream<Stream<T>>`），将其转换为一个扁平化的流。

以下是 `flatMap` 的几种常见用法：

---

### **1. 扁平化嵌套列表**
`flatMap` 可以将嵌套的列表（如 `List<List<T>>`）转换为一个单一的流。

#### **示例：扁平化嵌套列表**
```java
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class FlatMapExample {
    public static void main(String[] args) {
        List<List<String>> nestedList = Arrays.asList(
                Arrays.asList("Apple", "Banana"),
                Arrays.asList("Orange", "Grape"),
                Arrays.asList("Mango", "Pineapple")
        );

        // 使用 flatMap 扁平化嵌套列表
        List<String> flatList = nestedList.stream()
                .flatMap(List::stream) // 将每个内部列表转换为流
                .collect(Collectors.toList());

        System.out.println(flatList); // 输出: [Apple, Banana, Orange, Grape, Mango, Pineapple]
    }
}
```

---

### **2. 扁平化嵌套流**
`flatMap` 可以将嵌套的流（如 `Stream<Stream<T>>`）转换为一个单一的流。

#### **示例：扁平化嵌套流**
```java
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

public class FlatMapExample {
    public static void main(String[] args) {
        List<String> list1 = Arrays.asList("Apple", "Banana");
        List<String> list2 = Arrays.asList("Orange", "Grape");
        List<String> list3 = Arrays.asList("Mango", "Pineapple");

        // 使用 flatMap 扁平化嵌套流
        Stream<String> flatStream = Stream.of(list1.stream(), list2.stream(), list3.stream())
                .flatMap(stream -> stream); // 将每个流合并为一个流

        flatStream.forEach(System.out::println);
    }
}
```

**输出：**
```
Apple
Banana
Orange
Grape
Mango
Pineapple
```

---

### **3. 处理嵌套对象**
`flatMap` 可以用于处理嵌套对象中的集合或流。

#### **示例：扁平化嵌套对象中的集合**
```java
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

class User {
    private String name;
    private List<String> hobbies;

    public User(String name, List<String> hobbies) {
        this.name = name;
        this.hobbies = hobbies;
    }

    public List<String> getHobbies() {
        return hobbies;
    }
}

public class FlatMapExample {
    public static void main(String[] args) {
        List<User> users = Arrays.asList(
                new User("Alice", Arrays.asList("Reading", "Swimming")),
                new User("Bob", Arrays.asList("Cycling", "Hiking")),
                new User("Charlie", Arrays.asList("Painting", "Dancing"))
        );

        // 使用 flatMap 获取所有用户的爱好
        List<String> allHobbies = users.stream()
                .flatMap(user -> user.getHobbies().stream()) // 将每个用户的爱好列表转换为流
                .collect(Collectors.toList());

        System.out.println(allHobbies); // 输出: [Reading, Swimming, Cycling, Hiking, Painting, Dancing]
    }
}
```

---

### **4. 处理嵌套的 `Optional`**
`flatMap` 可以用于处理嵌套的 `Optional`，避免 `Optional<Optional<T>>` 的情况。

#### **示例：扁平化嵌套的 `Optional`**
```java
import java.util.Optional;

public class FlatMapExample {
    public static void main(String[] args) {
        Optional<String> optional1 = Optional.of("Hello");
        Optional<Optional<String>> nestedOptional = Optional.of(optional1);

        // 使用 flatMap 扁平化嵌套的 Optional
        Optional<String> flatOptional = nestedOptional.flatMap(opt -> opt);

        flatOptional.ifPresent(System.out::println); // 输出: Hello
    }
}
```

---

### **5. 处理嵌套的数组**
`flatMap` 可以用于将嵌套的数组（如 `String[][]`）转换为一个单一的流。

#### **示例：扁平化嵌套数组**
```java
import java.util.Arrays;
import java.util.stream.Stream;

public class FlatMapExample {
    public static void main(String[] args) {
        String[][] nestedArray = {
                {"Apple", "Banana"},
                {"Orange", "Grape"},
                {"Mango", "Pineapple"}
        };

        // 使用 flatMap 扁平化嵌套数组
        Stream<String> flatStream = Arrays.stream(nestedArray)
                .flatMap(Arrays::stream); // 将每个内部数组转换为流

        flatStream.forEach(System.out::println);
    }
}
```

**输出：**
```
Apple
Banana
Orange
Grape
Mango
Pineapple
```

---

### **总结**
- **扁平化嵌套集合**：如 `List<List<T>>`。
- **扁平化嵌套流**：如 `Stream<Stream<T>>`。
- **处理嵌套对象**：如对象中的集合或流。
- **处理嵌套 `Optional`**：避免 `Optional<Optional<T>>`。
- **扁平化嵌套数组**：如 `String[][]`。

`flatMap` 是处理嵌套结构的强大工具，能够将复杂的嵌套数据转换为单一的流。如果有其他问题，请随时提问！